PC World Komputer 2010 April/PCWorld0410.iso/hity wydania/Ubuntu 9.10 PL/karmelkowy-koliberek-desktop-9.10-i386-PL.iso/casper/filesystem.squashfs/usr/lib/python2.6/_abcoll.pyc

Python Compiled Bytecode | 2009-11-11 | 21KB | 692 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

"""Abstract Base Classes (ABCs) for collections, according to PEP 3119.

DON'T USE THIS MODULE DIRECTLY!  The classes here should be imported
via collections; they are defined here only to alleviate certain
bootstrapping issues.  Unit tests are in test_collections.
"""
from abc import ABCMeta, abstractmethod
import sys
__all__ = [
    'Hashable',
    'Iterable',
    'Iterator',
    'Sized',
    'Container',
    'Callable',
    'Set',
    'MutableSet',
    'Mapping',
    'MutableMapping',
    'MappingView',
    'KeysView',
    'ItemsView',
    'ValuesView',
    'Sequence',
    'MutableSequence']

class Hashable:
    __metaclass__ = ABCMeta

    def __hash__(self):
        return 0

    __hash__ = abstractmethod(__hash__)

    def __subclasshook__(cls, C):
        if cls is Hashable:
            for B in C.__mro__:
                if '__hash__' in B.__dict__:
                    if B.__dict__['__hash__']:
                        return True
                    break
                    continue
                B.__dict__['__hash__']


        return NotImplemented

    __subclasshook__ = classmethod(__subclasshook__)


class Iterable:
    __metaclass__ = ABCMeta

    def __iter__(self):
        while False:
            yield None

    __iter__ = abstractmethod(__iter__)

    def __subclasshook__(cls, C):
        if cls is Iterable:
            if any((lambda .0: for B in .0:
'__iter__' in B.__dict__)(C.__mro__)):
                return True

        return NotImplemented

    __subclasshook__ = classmethod(__subclasshook__)

Iterable.register(str)

class Iterator(Iterable):

    def next(self):
        raise StopIteration

    next = abstractmethod(next)

    def __iter__(self):
        return self


    def __subclasshook__(cls, C):
        if cls is Iterator:
            if any((lambda .0: for B in .0:
'next' in B.__dict__)(C.__mro__)):
                return True

        return NotImplemented

    __subclasshook__ = classmethod(__subclasshook__)


class Sized:
    __metaclass__ = ABCMeta

    def __len__(self):
        return 0

    __len__ = abstractmethod(__len__)

    def __subclasshook__(cls, C):
        if cls is Sized:
            if any((lambda .0: for B in .0:
'__len__' in B.__dict__)(C.__mro__)):
                return True

        return NotImplemented

    __subclasshook__ = classmethod(__subclasshook__)


class Container:
    __metaclass__ = ABCMeta

    def __contains__(self, x):
        return False

    __contains__ = abstractmethod(__contains__)

    def __subclasshook__(cls, C):
        if cls is Container:
            if any((lambda .0: for B in .0:
'__contains__' in B.__dict__)(C.__mro__)):
                return True

        return NotImplemented

    __subclasshook__ = classmethod(__subclasshook__)


class Callable:
    __metaclass__ = ABCMeta

    def __call__(self, *args, **kwds):
        return False

    __call__ = abstractmethod(__call__)

    def __subclasshook__(cls, C):
        if cls is Callable:
            if any((lambda .0: for B in .0:
'__call__' in B.__dict__)(C.__mro__)):
                return True

        return NotImplemented

    __subclasshook__ = classmethod(__subclasshook__)


class Set(Sized, Iterable, Container):
    '''A set is a finite, iterable container.

    This class provides concrete generic implementations of all
    methods except for __contains__, __iter__ and __len__.

    To override the comparisons (presumably for speed, as the
    semantics are fixed), all you have to do is redefine __le__ and
    then the other operations will automatically follow suit.
    '''

    def __le__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        if len(self) > len(other):
            return False
        for elem in self:
            if elem not in other:
                return False

        return True


    def __lt__(self, other):
        return isinstance(other, Set) if not isinstance(other, Set) else self.__le__(other)


    def __gt__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return other < self


    def __ge__(self, other):
        if not isinstance(other, Set):
            return NotImplemented
        return other <= self


    def __eq__(self, other):
        return isinstance(other, Set) if not isinstance(other, Set) else self.__le__(other)


    def __ne__(self, other):
        return not (self == other)


    def _from_iterable(cls, it):
        '''Construct an instance of the class from any iterable input.

        Must override this method if the class constructor signature
        does not accept an iterable for an input.
        '''
        return cls(it)

    _from_iterable = classmethod(_from_iterable)

    def __and__(self, other):
        if not isinstance(other, Iterable):
            return NotImplemented
        return (self._from_iterable,)((lambda .0: for value in .0:
if value in self:
valuecontinue)(other))


    def isdisjoint(self, other):
        for value in other:
            if value in self:
                return False

        return True


    def __or__(self, other):
        if not isinstance(other, Iterable):
            return NotImplemented
        chain = (lambda .0: for s in .0:
for e in s:
e)((self, other))
        return self._from_iterable(chain)


    def __sub__(self, other):
        if not isinstance(other, Set):
            if not isinstance(other, Iterable):
                return NotImplemented
            other = self._from_iterable(other)

        return (self._from_iterable,)((lambda .0: for value in .0:
if value not in other:
valuecontinue)(self))


    def __xor__(self, other):
        if not isinstance(other, Set):
            if not isinstance(other, Iterable):
                return NotImplemented
            other = self._from_iterable(other)

        return self - other | other - self

    __hash__ = None

    def _hash(self):
        """Compute the hash value of a set.

        Note that we don't define __hash__: not all sets are hashable.
        But if you define a hashable set type, its __hash__ should
        call this function.

        This must be compatible __eq__.

        All sets ought to compare equal if they contain the same
        elements, regardless of how they are implemented, and
        regardless of the order of the elements; so there's not much
        freedom for __eq__ or __hash__.  We match the algorithm used
        by the built-in frozenset type.
        """
        MAX = sys.maxint
        MASK = 2 * MAX + 1
        n = len(self)
        h = 1927868237 * (n + 1)
        h &= MASK
        for x in self:
            hx = hash(x)
            h ^= (hx ^ hx << 16 ^ 89869747) * 0xD93F34D7L
            h &= MASK

        h = h * 69069 + 907133923
        h &= MASK
        if h > MAX:
            h -= MASK + 1

        if h == -1:
            h = 590923713

        return h


Set.register(frozenset)

class MutableSet(Set):

    def add(self, value):
        '''Add an element.'''
        raise NotImplementedError

    add = abstractmethod(add)

    def discard(self, value):
        '''Remove an element.  Do not raise an exception if absent.'''
        raise NotImplementedError

    discard = abstractmethod(discard)

    def remove(self, value):
        '''Remove an element. If not a member, raise a KeyError.'''
        if value not in self:
            raise KeyError(value)
        value not in self
        self.discard(value)


    def pop(self):
        '''Return the popped value.  Raise KeyError if empty.'''
        it = iter(self)

        try:
            value = next(it)
        except StopIteration:
            raise KeyError

        self.discard(value)
        return value


    def clear(self):
        '''This is slow (creates N new iterators!) but effective.'''

        try:
            while True:
                self.pop()
        except KeyError:
            pass



    def __ior__(self, it):
        for value in it:
            self.add(value)

        return self


    def __iand__(self, it):
        for value in self - it:
            self.discard(value)

        return self


    def __ixor__(self, it):
        if not isinstance(it, Set):
            it = self._from_iterable(it)

        for value in it:
            if value in self:
                self.discard(value)
                continue
            self.add(value)

        return self


    def __isub__(self, it):
        for value in it:
            self.discard(value)

        return self


MutableSet.register(set)

class Mapping(Sized, Iterable, Container):

    def __getitem__(self, key):
        raise KeyError

    __getitem__ = abstractmethod(__getitem__)

    def get(self, key, default = None):

        try:
            return self[key]
        except KeyError:
            return default



    def __contains__(self, key):

        try:
            self[key]
        except KeyError:
            return False

        return True


    def iterkeys(self):
        return iter(self)


    def itervalues(self):
        for key in self:
            yield self[key]



    def iteritems(self):
        for key in self:
            yield (key, self[key])



    def keys(self):
        return list(self)


    def items(self):
        return [ (key, self[key]) for key in self ]


    def values(self):
        return [ self[key] for key in self ]

    __hash__ = None

    def __eq__(self, other):
        if isinstance(other, Mapping):
            pass
        return dict(self.items()) == dict(other.items())


    def __ne__(self, other):
        return not (self == other)



class MappingView(Sized):

    def __init__(self, mapping):
        self._mapping = mapping


    def __len__(self):
        return len(self._mapping)



class KeysView(MappingView, Set):

    def __contains__(self, key):
        return key in self._mapping


    def __iter__(self):
        for key in self._mapping:
            yield key




class ItemsView(MappingView, Set):

    def __contains__(self, item):
        (key, value) = item

        try:
            v = self._mapping[key]
        except KeyError:
            return False

        return v == value


    def __iter__(self):
        for key in self._mapping:
            yield (key, self._mapping[key])




class ValuesView(MappingView):

    def __contains__(self, value):
        for key in self._mapping:
            if value == self._mapping[key]:
                return True

        return False


    def __iter__(self):
        for key in self._mapping:
            yield self._mapping[key]




class MutableMapping(Mapping):

    def __setitem__(self, key, value):
        raise KeyError

    __setitem__ = abstractmethod(__setitem__)

    def __delitem__(self, key):
        raise KeyError

    __delitem__ = abstractmethod(__delitem__)
    __marker = object()

    def pop(self, key, default = __marker):

        try:
            value = self[key]
        except KeyError:
            if default is self._MutableMapping__marker:
                raise
            default is self._MutableMapping__marker
            return default

        del self[key]
        return value


    def popitem(self):

        try:
            key = next(iter(self))
        except StopIteration:
            raise KeyError

        value = self[key]
        del self[key]
        return (key, value)


    def clear(self):

        try:
            while True:
                self.popitem()
        except KeyError:
            pass



    def update(self, other = (), **kwds):
        if isinstance(other, Mapping):
            for key in other:
                self[key] = other[key]

        elif hasattr(other, 'keys'):
            for key in other.keys():
                self[key] = other[key]

        else:
            for key, value in other:
                self[key] = value

        for key, value in kwds.items():
            self[key] = value



    def setdefault(self, key, default = None):

        try:
            return self[key]
        except KeyError:
            self[key] = default

        return default


MutableMapping.register(dict)

class Sequence(Sized, Iterable, Container):
    '''All the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    '''

    def __getitem__(self, index):
        raise IndexError

    __getitem__ = abstractmethod(__getitem__)

    def __iter__(self):
        i = 0

        try:
            while True:
                v = self[i]
                yield v
                i += 1
        except IndexError:
            return None



    def __contains__(self, value):
        for v in self:
            if v == value:
                return True

        return False


    def __reversed__(self):
        for i in reversed(range(len(self))):
            yield self[i]



    def index(self, value):
        for i, v in enumerate(self):
            if v == value:
                return i

        raise ValueError


    def count(self, value):
        return (sum,)((lambda .0: for v in .0:
if v == value:
1continue)(self))


Sequence.register(tuple)
Sequence.register(basestring)
Sequence.register(buffer)
Sequence.register(xrange)

class MutableSequence(Sequence):

    def __setitem__(self, index, value):
        raise IndexError

    __setitem__ = abstractmethod(__setitem__)

    def __delitem__(self, index):
        raise IndexError

    __delitem__ = abstractmethod(__delitem__)

    def insert(self, index, value):
        raise IndexError

    insert = abstractmethod(insert)

    def append(self, value):
        self.insert(len(self), value)


    def reverse(self):
        n = len(self)
        for i in range(n // 2):
            self[i] = self[n - i - 1]
            self[n - i - 1] = self[i]



    def extend(self, values):
        for v in values:
            self.append(v)



    def pop(self, index = -1):
        v = self[index]
        del self[index]
        return v


    def remove(self, value):
        del self[self.index(value)]


    def __iadd__(self, values):
        self.extend(values)
        return self


MutableSequence.register(list)